<template>
  <div>
    <button @click="exportToExcel">导出 Excel</button>
    <!-- <div>{{ receivedData }}</div> -->
  </div>
</template>

<script>
import * as XLSX from "xlsx";
import { EventBus } from "@/event";
// import Decimal from 'decimal.js';
export default {
  data() {
    return {
      receivedData: [], // 修改为数组
    };
  },
  created() {
    EventBus.$on("data-sent", (data) => {
      this.receivedData = data;
      // console.log('Received Data', this.receivedData);
    });

  },
  methods: {
    exportToExcel() {
      // 示例数据
      const data = [
        ["编号", "x", "y", "高程"], // 表头
        ...this.receivedData,
      ];

      // 计算最大值和最小值
      let max = -Infinity;
      let min = Infinity;

      for (let i = 0; i < this.receivedData.length; i++) {
        const value = this.receivedData[i][3]; // 假设高程在第四列
        if (typeof value === "number") {
          if (value > max) max = value; // 更新最大值
          if (value < min) min = value; // 更新最小值
        }
      }

      // 计算差值
      const difference =
        max === -Infinity || min === Infinity ? null : (max - min) * 1000;
      // 计算刀数
      const DK = 35
      const dividedDifference =
        difference !== null ? Math.ceil(difference / DK) : null;

      // 处理 x 值相同的 y 值
      const yValuesMap = new Map();

      for (let i = 0; i < this.receivedData.length; i++) {
        const xValue = this.receivedData[i][1]; // x 在第二列
        const yValue = this.receivedData[i][2]; // y 在第三列

        if (!yValuesMap.has(xValue)) {
          yValuesMap.set(xValue, []);
        }
        yValuesMap.get(xValue).push(yValue); // 将 y 值存入对应 x 值的数组中
      }

      // 创建 Sheet3，包含原始数据和对应的标记
      const processedData = data.slice(1); // 去掉表头
      const sheet3Data = [
        [
          "编号",
          "x",
          "y",
          "高程",
          "标记",
          "打印深度",
          ...Array.from({ length: dividedDifference }).map((_, index) => `CVN_${index + 1}`),
        ],
      ]; // Sheet3 的表头


      for (let i = 0; i < processedData.length; i++) {
        let xValue = processedData[i][1];
        let correspondingYValues = yValuesMap.get(xValue); // 获取对应的 y 值数组

        if (correspondingYValues) {
          let maxY = Math.max(...correspondingYValues);
          let minY = Math.min(...correspondingYValues);

          // 标记最大值、最小值和其他值
          let yValue = processedData[i][2];
          let label = yValue === maxY ? "B" : yValue === minY ? "A" : "C";

          //打印深度：计算与最大值的差值并乘以1000
          // const heightValue = processedData[i][3]; // 高程值
          // let differenceFromMax =new Decimal(max).sub(new Decimal(processedData[i][3])).toNumber(); // 与最大值的差
          // let result = differenceFromMax * 1000; // 乘以 1000
          let roundedResult = Math.round((max - processedData[i][3]) * 1000); // 四舍五入打印深度值

          // 创建长度为刀数的数组，所有初始元素为0
          var cvnArr = Array(dividedDifference).fill(-99);

          if (roundedResult < 35) {
            cvnArr[0] = roundedResult;
          } else {
            // 如果大于一刀的在这里面处理
            cvnArr[0] = 35;
            // [35,70,72] [35,75,-999]
            let nextdeepth = roundedResult - 35;

            for (let j = 1; j < dividedDifference; j++) {

              if (nextdeepth > 35) {
                cvnArr[j] = 35 * (j + 1);
              } else {
                cvnArr[j] = roundedResult;
                break;
              }
              nextdeepth -= 35
            }
          }
          // console.log(cvnArr)

          // const presult = [...processedData[i],...cvnArr]

          // console.log(presult )



          // //计算CVN1的值
          // const cvn1 = 35;

          // //计算CVN_2的值
          // let cvn_2;
          // if (roundedResult < 70) {
          //   cvn_2 = roundedResult; // 如果打印深度小于 70，则 CVN2 等于 roundedResult
          // } else {
          //   cvn_2 = 70; // 如果打印深度大于等于 70，则 CVN2 等于 70
          // }

          // //计算cvn_3的值
          // let cvn_3;
          // const divisor = 35 * 2; // 计算除数，70
          // const quotient = roundedResult / divisor; // 计算商

          // if (quotient >= 1) {
          //   cvn_3 = roundedResult; // 如果商大于等于 1，则 cvn_3 等于对应打印深度
          // } else {
          //   cvn_3 = -9999; // 否则，cvn_3 赋值为 -9999
          // }

          // //计算cvn_4的值
          // let cvn_4;
          // const divisor2 = 35 * 3; // 计算除数，70
          // const quotient2 = roundedResult / divisor2; // 计算商

          // if (quotient2 >= 1) {
          //   cvn_4 = roundedResult; // 如果商大于等于 1，则 cvn_3 等于对应打印深度
          // } else {
          //   cvn_4 = -9999; // 否则，cvn_3 赋值为 -9999
          // }
          // //计算cvn_5的值
          // let cvn_5;
          // const divisor3 = 35 * 4; // 计算除数，70
          // const quotient3 = roundedResult / divisor3; // 计算商

          // if (quotient3 >= 1) {
          //   cvn_5 = roundedResult; // 如果商大于等于 1，则 cvn_3 等于对应打印深度
          // } else {
          //   cvn_5 = -9999; // 否则，cvn_3 赋值为 -9999
          // }

          // 将原始数据和标记一起添加到 Sheet3 数据中
          sheet3Data.push([
            ...processedData[i],
            label,
            roundedResult,
            ...cvnArr
          ]);
        }
      }



      // console.log(sheet3Data)

      //#1
      // 创建 Sheet4，包含 CVN1 不为 -9999 的行
      // const cvn1Index = sheet3Data[0].indexOf("CVN1"); // 获取 CVN1 所在列的索引
      // const filteredCVN1Data = sheet3Data.filter((row) => {
      //   // console.log(row); // 打印当前的 row
      //   // console.log(row[cvn1Index])
      //   return row[cvn1Index] !== -9999; // 筛选条件
      // }); // 筛选 CVN1 不为 -9999 的行

      // // console.log(row)
      // // console.log(cvn1Index)//6
      // console.log(filteredCVN1Data);
      // // 提取需要的列

      // const sheet4Data = filteredCVN1Data.map((item) => {
      //   // console.log(cvn1);
      //   return [
      //     item[0], // 编号
      //     item[1], // x
      //     item[2], // y
      //     item[4], // 标记
      //     item[6], // CVN1
      //   ];
      // });
      // console.log(sheet4Data)

      // 将数据转换为工作表
      const worksheet = XLSX.utils.aoa_to_sheet(data);

      // 创建一个新的工作簿，创建sheert1
      const workbook = XLSX.utils.book_new();
      XLSX.utils.book_append_sheet(workbook, worksheet, "Sheet1");

      // 创建 Sheet2，包含最大值和最小值以及差值
      const minMaxData = [
        ["最大值", "最小值", "差值", "刀数"],
        [
          max === -Infinity ? null : max,
          min === Infinity ? null : min,
          difference,
          dividedDifference,
        ],
      ];
      const minMaxWorksheet = XLSX.utils.aoa_to_sheet(minMaxData);
      XLSX.utils.book_append_sheet(workbook, minMaxWorksheet, "Sheet2");

      // 创建 Sheet3，包含原始数据和对应的标记
      const sheet3Worksheet = XLSX.utils.aoa_to_sheet(sheet3Data);
      XLSX.utils.book_append_sheet(workbook, sheet3Worksheet, "Sheet3");

      // 创建 Sheet4，包含 CVN1 数据
      // const sheet4Worksheet = XLSX.utils.aoa_to_sheet(sheet4Data);
      // XLSX.utils.book_append_sheet(workbook, sheet4Worksheet, "Sheet4");


      // 创建动态的 CVN 工作表
      for (let i = 0; i < dividedDifference; i++) {
        // 处理当前 CVN 工作表的数据
        const cvnWorksheetData = [
          ["编号", "x", "y", "标记", `CVN_${i + 1}`], // 表头
          ...sheet3Data
            .slice(1) // 跳过表头
            .filter(item => item[6 + i] !== -99)
            .map((item) => [
              item[0], // 编号
              item[1], // x
              item[2], // y
              item[4], // 标记
              item[6 + i], // 当前CVN值
            ])
        ];

        // 创建新的工作表并添加到工作簿中
        const cvnWorksheet = XLSX.utils.aoa_to_sheet(cvnWorksheetData);
        XLSX.utils.book_append_sheet(workbook, cvnWorksheet, `${i + 1}#`);
      }
      // 导出文件
      XLSX.writeFile(workbook, "导出数据.xlsx");
    },
  },
};
</script>

<style scoped>
button {
  padding: 10px 15px;
  background-color: #42b983;
  color: white;
  border: none;
  cursor: pointer;
}
</style>
